# nbi:hide_in
from __future__ import print_function
from ipywidgets import interact, interactive, fixed, interact_manual
import ipywidgets as widgets
import nbinteract as nbi
from IPython.display import display
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.pyplot import figure, savefig
from pandas import DataFrame
from IPython.display import HTML, IFrame
import sys 
sys.path.append('/home/nico/.local/lib/python3.8/site-packages')
from lcapy import Circuit


fig_sz_x = 10
fig_sz_y = 10
fig_dpi = 80 # dpi

fig_font_family = 'Ubuntu'
fig_font_size = 14

plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})

Funciones trigonométricas

Vamos a usar las coordenadas $x$ (la abscisa) y la coordenada $y$ (la ordenada) del punto $P(x,y)$ para definir varias funciones trigonométricas. Por ejemplo, definimos a la función llamada seno asignando a cada número real t la coordenada $y$ del punto $P(x,y)$ determinado por $t$. Las funciones coseno, tangente, cosecante, secante y cotangente también se definen usando las coordenadas del punto $P(x,y)$.

Solo a modo informativo definiremos estas seis funciones pero nos concentraremos en la función seno y coseno , que son las que se utilizan en nuestra rama de estudio.

Definición de funciones trigonométricas: Sea $t$ un número real y sea $P(x,y)$ el punto del circulo unitario determinado por $t$. $$$$ $$sen(t)=y$$ $$$$ $$cos(t)=x$$ $$$$ $$tg(t)=\frac{y}{x}; x \ne 0$$ $$$$ $$cosec(t)=\frac{1}{y}; y \ne 0$$ $$$$ $$sec(t)=\frac{1}{x}; x \ne 0$$ $$$$ $$cotg(t)=\frac{x}{y}; y \ne 0$$

Estas definiciones se pueden aplicar a círculos no unitarios con una pequeña modificación. Anterior mente vimos que simplificamos la variable $r$ porque su valor era igual a $1$, si no lo es queda:

Definición de funciones trigonométricas con radio $\ne$ 1: Sea $t$ un número real y sea $P(x,y)$ el punto del circulo unitario determinado por $t$. $$$$ $$sen(t)=\frac{y}{r}$$ $$$$ $$cos(t)=\frac{x}{r}$$ $$$$ $$tg(t)=\frac{y}{x}; x \ne 0$$ $$$$ $$cosec(t)=\frac{r}{y}; y \ne 0$$ $$$$ $$sec(t)=\frac{r}{x}; x \ne 0$$ $$$$ $$cotg(t)=\frac{x}{y}; y \ne 0$$

Veamos que representan gráficamente estas funciones en el círculo unitario.

  • $t$ es el arco de circunferencia.
  • $P$ es el punto que esta determinado por el arco de circunferencia.

.

  • Podemos ver al $sen(\alpha)$ como la proyección del radio sobre el eje $y$. En otras palabras el el valor de la ordenada (el eje $y$), su altura, en el punto $P$.

.

  • Podemos ver al $cos(\alpha)$ como la proyección del radio sobre el eje $x$. En otras palabras el el valor de la abscisa (el eje $x$), su largo, en el punto $P$.
  • Podemos ver al la $tg(\alpha)$ como la untersección de la continuación del raido con la recta tangente al punto $P(1,0)$. En otras palabras el valor de la altura del punto $Q$.

.

Podemos ver que se nos formó un triángulo formado por el segmento en rojo $\overline{OA}$ , llamado cateto adyacente, el segmento en azul $\overline{AP}$ , llamado cateto opuesto, y el segmento en celeste $\overline{OP}$ , llamado hipotenusa, podemos definir las funciones trigonométricas como:

Definición de funciones trigonométricas de ángulos: Sea $\alpha$ un ángulo formado entre el cateto adyacente y la hipotenusa. $$$$ $$sen(\alpha)=\frac{cat. op}{hip}$$ $$$$ $$cos(\alpha)=\frac{cat. ady}{hip}$$ $$$$ $$tg(\alpha)=\frac{cat. op}{cat. ady}$$ $$$$ $$cosec(\alpha)=\frac{hip}{cat. op}$$ $$$$ $$sec(\alpha)=\frac{hip}{cat. ady}$$ $$$$ $$cotg(\alpha)=\frac{cat. ady}{cat. op}$$

de esta manera definimos a las funciones trigonométricas en función del ángulo $\alpha$.

Dominio

Esto es solo a modo informativo.

Funciones Dominio
$sen, cos$ $\mathbb{R}$
$tg, sec$ $\mathbb{R} - \frac{\pi}{2}$+$n\pi$ para $n \in \mathbb{Z}$
cotg, cosec $\mathbb{R} -$ $n \pi$ para $n \in \mathbb{Z}$

Signos

Recordemos que el seno es el valor de la ordenada en el punto $P$, su altura, en el círculo unitario. por lo cual ¿Cuáles son los valores posibles del seno? Teniendo el círculo en mente podemos notar que la altura empieza en $0$ luego va creciendo hasta llegar a $1$. Continuando va decreciendo hasta llegar nuevamente en $0$. A partir de acá empieza a crecer de forma negativa hasta llegar a $-1$ y vuelve a a decrecer hasta llegar a $0$. Veamos esto gráficamente.

Solo tienen que presionar play. 
# nbi:hide_in
%matplotlib inline
from matplotlib.animation import FuncAnimation

plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})

plt.style.use('seaborn-pastel')
N = 200
TWOPI = 2*np.pi
t = np.linspace(0, 2*np.pi, N)
x = np.cos(t) 
y = np.sin(t) 
    

fig, ax = plt.subplots(figsize=(6, 6), dpi= fig_dpi, facecolor='w', edgecolor='k')
plt.axhline(0, color="grey")
plt.axvline(0, color="grey")
plt.grid('on')
plt.title("Función senoidal" )

plt.plot(x,y)

ax = plt.axis([-1.1,1.1,-1.1,1.1])

redDot, = plt.plot([], [], 'ro')
text = plt.text(0,0,'',fontsize=16,bbox=dict(facecolor='lightblue', alpha=1),
               horizontalalignment='center', verticalalignment='center')
#arrow = plt.arrow([], 0, 0, [], head_width=0.05, head_length=0.1, fc='r', ec='r')

line, = plt.plot(x,y,'r', lw=2)

def init():
    line, = ax.plot(1,0, 'ro')
    return line,


def animate(i):
    plt.close() # por algun motivo que desconozco poniendolo aca borra el plot extra que aparece.
    redDot.set_data(x[i],y[i])
    text.set_text('y='+ str(np.round(y[i],3)))
    #arrow.set_data(x[i],y[i])
    line.set_data([x[i],x[i]], [0,y[i]])

    return redDot, line, text,  #arrow

# create animation using the animate() function
anim = FuncAnimation(fig, animate, frames=N, interval=100, blit=True, repeat=True)
                                      

HTML(anim.to_jshtml())

Algo similar ocurre con la función coseno, con la diferencia que al ser el valor de la abscisa en el punto $P$, el largo del triángulo, esta parece empezar desplazada. Note que en este caso en ves de empezar con ancho $0$ empieza con un ancho de valor $1$. Sin embargo el recorrido es el mismo.

# nbi:hide_in
%matplotlib inline
from matplotlib.animation import FuncAnimation

plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})

plt.style.use('seaborn-pastel')
N = 200
TWOPI = 2*np.pi
t = np.linspace(0, 2*np.pi, N)
x = np.cos(t) 
y = np.sin(t) 
    

fig, ax = plt.subplots(figsize=(6, 6), dpi= fig_dpi, facecolor='w', edgecolor='k')
plt.axhline(0, color="grey")
plt.axvline(0, color="grey")
plt.grid('on')
plt.title("Función coseno" )

plt.plot(x,y)

ax = plt.axis([-1.1,1.1,-1.1,1.1])

redDot, = plt.plot([], [], 'ro')
text = plt.text(0,0,'',fontsize=16,bbox=dict(facecolor='lightblue', alpha=1),
               horizontalalignment='center', verticalalignment='center')
#arrow = plt.arrow([], 0, 0, [], head_width=0.05, head_length=0.1, fc='r', ec='r')

line, = plt.plot(x,y,'r', lw=2)

def init():
    line, = ax.plot(1,0, 'ro')
    return line,


def animate(i):
    plt.close() # por algun motivo que desconozco poniendolo aca borra el plot extra que aparece.
    redDot.set_data(x[i],y[i])
    text.set_text('x='+ str(np.round(x[i],3)))
    #arrow.set_data(x[i],y[i])
    line.set_data([0,x[i]], [y[i],y[i]])

    return redDot, line, text,  #arrow

# create animation using the animate() function
anim = FuncAnimation(fig, animate, frames=N, interval=100, blit=True, repeat=True)
                                      

HTML(anim.to_jshtml())

Como vemos de las animaciones llegamos a la siguiente conclusión para estas dos funciones:

cuadrante Función positiva función negativa
I todas ninguna
II seno cosen
III tg coseno y seno
IV coseno seno
La regla mnemotécnica es la siguiente: En el primer cuadrante son todas. En el Segundo cuadrante es el Seno, (ambos empiezan con la letra S). En el Tercer cuadrante es la Tangente, (ambos empiezan con la letra T) y en el Cuarto cuadrante es el Coseno, (ambos empiezan con la letra C) .

Esto es un regla para memorizarlo, pero si recuerdan las definiciones se daran cuenta que esto es así por los signos de la variable $x$ e $y$ que usamos para definir las funciones.

Propiedad par e impar

La función senoidal es impar por lo cual. $sen(t)=-sen(-t)$ $$$$ La función cosenoidal es par por lo cual. $sen(-t)=sen(t)$ $$$$ Donde $t \in \mathbb{R}$

Gráfica de la función senoidal y cosenoidal.

Fue un camino largo pero llegamos a lo mas relevante para nosotros, conocer la gráfica de estas funciones. Esto nos va a permitir tener una mejor comprensión de su comportamiento.

Antes de graficarlas debemos notar algo, y es que dichas funciones se repiten cada vez que realizan una vuelta, es decir, al terminar una vuelta y comenzar una nueva se vuelven a repetir todos sus valores. A este tipo de funciones que se repiten se les llama periodicas y su periodo en este caso es $2\pi$ ya que recordemos que esa es la distancia que recorre el punto $P$ a lo largo de la circunferencia unitaria (esta distancia es el diámetro de la circunferencia). Por lo cual el valor del punto $P(x,y)$ determinado por el número real $t$ es el mismo que el determinado por $t+2\pi$.

Matemáticamente esto se escribe de la siguiente forma:

$$sen(t)=sen(t + 2n\pi); n \in \mathbb{Z}$$ $$$$ $$cos(t)=cos(t + 2n\pi); n \in \mathbb{Z}$$

$n$ representa el número de vueltas.

De todas formas retomaremos esto mas adelante, no se desanimen si no lo terminan de entender ahora, al ver la gráfica les va a quedar mas claro.

Gráfica de función senoidal

Comencemos a graficar la función $senoidal$. Para ello recordemos que $sen(t)$ es la coordenada $y$ del $P(x,y)$ en la circunferencia unitaria determinado por el número real $t$. Recordemos de la animación que a medida que aumenta $t$ el valor del seno aumenta hasta llegar a $1$, luego disminuye hasta llegar a $-1$ y finalmente aumenta hasta llegar a $0$ y vuelve a comenzar.

Obtendremos la gráfica representando el valor de $y$ para cada valor de $t$ en un eje cartesiano y luego uniendo los puntos. Es el mismo método que usamos antes armando una tabla. La animación siguiente les muestra este proceso.

# nbi:hide_in
%matplotlib inline
from matplotlib.animation import FuncAnimation

plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})

plt.style.use('seaborn-pastel')
N = 200
N1 = 25
TWOPI = 2*np.pi
t  = np.linspace(0, 2*np.pi, N)
t1 = np.linspace(0, 2*np.pi, N1)
x = np.cos(t) -1
y = np.sin(t)
x1 = np.cos(t1) -1
y1 = np.sin(t1)
    
figure
fig  = plt.figure(figsize=(20, 6), dpi= fig_dpi, facecolor='w', edgecolor='k')
ax = plt.axes(xlim=(-2.1,2*np.pi+0.1), ylim=(-1.1,1.1))
plt.axhline(0, color="grey")
plt.axvline(0, color="grey")
plt.axvline(-1, color="grey")
plt.grid('on')
plt.xlabel('$t[rad]$',fontsize=14)
plt.title("$Función$ $senoidal$" )



ax.plot(x,y,label='$sen(t)$')
ax.legend(loc='upper right')



redDot, = ax.plot([], [], 'ro')
text = ax.text(-1,0,'',fontsize=16,bbox=dict(facecolor='lightblue', alpha=1),
               horizontalalignment='center', verticalalignment='center')
#arrow = plt.arrow([], 0, 0, [], head_width=0.05, head_length=0.1, fc='r', ec='r')

line, = ax.plot(x1,y1,'r', lw=2)

def init():
    line, = ax.plot(1,0, 'ro')
    return line,


def animate(i):
    plt.close() # por algun motivo que desconozco poniendolo aca borra el plot extra que aparece.
    if i < N1:
        ax.set_xticks([0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi])
        ax.set_xticklabels(["$0$", r"$\frac{1}{2}\pi$",r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"])
        redDot.set_data(x1[i],y1[i])
        ax.plot(t1[i],y1[i],'ro',lw=2)
        text.set_text('y='+ str(np.round(y1[i],3)))
        #arrow.set_data(x[i],y[i])
        line.set_data([x1[i],x1[i]], [0,y1[i]])
    elif i == N1+1:
        ax.plot(t,y,'b',lw=2,)
    return redDot, line, text, #arrow

# create animation using the animate() function
anim = FuncAnimation(fig, animate, frames=N1+8, interval=400, blit=True, repeat=True)
                                      

HTML(anim.to_jshtml())

Observaciones

  1. Vemos que una parte de la señal es positiva y otra es negativa.

  2. Vemos que tiene un valor máximo cuando $t=\frac{\pi}{2}$

  3. Vemos que tiene un valor mínimo cuando $t=\frac{3\pi}{2}$

  4. vemos que intersecta al eje $x$ (los ceros de la función) en tres lugares. En $x=0$, en $x=\pi$ y en $x=2\pi$

  5. No se puede observar en este gráfico pero la señal se repite cada $t=t+2n\pi$ como mencionamos anteriormente.

Estos 5 puntos que mencionamos son muy relevantes, los estudiaremos en detalle en el siguiente capítulo.

Gráfica de función cosenoidal

De la misma forma vamos a graficar la función $cosenoidal$. Para ello recordemos que $cos(t)$ es la coordenada $x$ del $P(x,y)$ en la circunferencia unitaria determinado por el número real $t$. Recordemos de la animación que comienza con $x=1$ y medida que aumenta $t$ el valor del $cos$ disminuye hasta llegar a $0$, sigue disminuyendo hasta llegar a $-1$ y finalmente aumenta hasta llegar a $1$ y vuelve a comenzar.

Obtendremos la gráfica representando el valor de $x$ para cada valor de $t$ en un eje cartesiano y luego uniendo los puntos. Es similar al caso anterior, pero preste atención a la forma de la señal y compárela con la señal $senoidal$

# nbi:hide_in
%matplotlib inline
from matplotlib.animation import FuncAnimation

plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})

plt.style.use('seaborn-pastel')
N = 200
N1 = 25
TWOPI = 2*np.pi
t  = np.linspace(0, 2*np.pi, N)
t1 = np.linspace(0, 2*np.pi, N1)
x = np.cos(t) -1
y = np.sin(t)
x1 = np.cos(t1) -1
y1 = np.sin(t1)

    
figure
fig  = plt.figure(figsize=(20, 6), dpi= fig_dpi, facecolor='w', edgecolor='k')
ax = plt.axes(xlim=(-2.1,2*np.pi+0.1), ylim=(-1.1,1.1))
plt.axhline(0, color="grey")
plt.axvline(0, color="grey")
plt.axvline(-1, color="grey")
plt.grid('on')
plt.xlabel('$t[rad]$',fontsize=14)
plt.title("$Función$ $cosenoidal$" )



ax.plot(x,y,label='$cos(t)$')
ax.legend(loc='upper center')



redDot, = ax.plot([], [], 'ro')
text = ax.text(-1,0,'',fontsize=16,bbox=dict(facecolor='lightblue', alpha=1),
               horizontalalignment='center', verticalalignment='center')
#arrow = plt.arrow([], 0, 0, [], head_width=0.05, head_length=0.1, fc='r', ec='r')

line, = ax.plot(x1,y1,'r', lw=2)

def init():
    line, = ax.plot(1,0, 'ro')
    return line,


def animate(i):
    plt.close() # por algun motivo que desconozco poniendolo aca borra el plot extra que aparece.
    if i < N1:
        ax.set_xticks([0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi])
        ax.set_xticklabels(["$0$", r"$\frac{1}{2}\pi$",r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"])
        redDot.set_data(x1[i],y1[i])
        ax.plot(t1[i],x1[i]+1,'ro',lw=2)
        text.set_text('x='+ str(np.round(x1[i],3)))
        #arrow.set_data(x[i],y[i])
        line.set_data([-1,x1[i]], [y1[i],y1[i]])
    elif i == N1+1:
        ax.plot(t,x+1,'b',lw=2,)
    return redDot, line, text, #arrow

# create animation using the animate() function
anim = FuncAnimation(fig, animate, frames=N1+8, interval=400, blit=True, repeat=True)
                                      

HTML(anim.to_jshtml())

  1. Vemos que una parte de la señal es positiva y otra es negativa.

  2. Vemos que tiene un valor máximo cuando $t=0$

  3. Vemos que tiene un valor mínimo cuando $t=\pi$

  4. vemos que intersecta al eje $x$ (los ceros de la función) en tres lugares. En $x=\frac{\pi}{2}$ y en $x=\frac{3\pi}{2}$

  5. No se puede observar en este gráfico pero la señal se repite cada $t=t+2n\pi$ como mencionamos anteriormente.

Note que la gráfica tiene la misma forma que la anterior solo que comienza en $1$ en vez de en $0$, por lo cual la señal **cosenoidal** es la misma señal **senoidal** desplazada hacia la izquierda $\frac{\pi}{2}$

Dejo esta inquietud planteada, lo retomaremos en el próximo capítulo. Puede revisar la propiedad de desplazamiento horizontal vista en la sección de Transformación de funciones. A continuación les dejo una animación que muestra esto.

# nbi:hide_in
%matplotlib inline
from matplotlib.animation import FuncAnimation

plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})

plt.style.use('seaborn-pastel')
fig = plt.figure(figsize=(8, 6), dpi= fig_dpi, facecolor='w', edgecolor='k')
ax = plt.axes(xlim=(-2*np.pi, 2*np.pi), ylim=(-2.2, 2.2))
plt.axhline(0, color="grey")
plt.axvline(0, color="grey")
plt.grid('on')
texto = ['$y=sin(x)$', '$y=sin(x+\pi/10)$', '$y=sin(x+\pi/5)$', '$y=(x+3\pi/10)$',
         '$y=sin(x+2\pi/5)$', '$y=sin(x+\pi/2)$', '$y=cos(x)$']


line, = ax.plot([], [], lw=2)
c = np.linspace(.0,np.pi/2,6)
x = np.linspace(-2*np.pi, 2*np.pi, 1000)

text = ax.text(0,1.4,texto[0],fontsize=16,bbox=dict(facecolor='lightblue', alpha=1),
                horizontalalignment='center', verticalalignment='bottom')

def init():
    line.set_data([], [])
    return line,

def animate(i):
    plt.close() # por algun motivo que desconozco poniendolo aca borra el plot extra que aparece.
    if i == 0:
        #ax.plot(x, x**2, lw=2,color='red', label='$y=x²$')
        #ax.legend(loc='upper center')
        ax.set_xticks([ -2*np.pi, -1.5*np.pi, -np.pi, -.5*np.pi, 0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi])
        ax.set_xticklabels([r"$-2\pi$", r"$\frac{-3}{2}\pi$", r"$-\pi$", r"$\frac{-1}{2}\pi$",  "$0$", 
                            r"$\frac{1}{2}\pi$",r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"])
        ax.plot(x, np.sin(x), lw=2,color='red')
        ax.text(0,1.8,texto[0],fontsize=16,bbox=dict(facecolor='red', alpha=0.5),
                horizontalalignment='center', verticalalignment='bottom')
    elif i<6:    
        y = np.sin(x+c[i])
        line.set_data(x, y)
        text.set_text(texto[i])
    else:
        text.set_text(texto[6])
        
    return line,text,

anim = FuncAnimation(fig, animate, init_func=init, frames=9, interval=1000, blit=True)
HTML(anim.to_jshtml())

#anim.save('imagenes/sine_wave.gif', writer='imagemagick')

Finalizando les dejo una animación que muestro esto mismo de una forma similar, pero que les permite ver varios períodos de la señal. Deben seleccionar la función y mover el punto. Eso les va a mostrar como se mueve el punto en la gráfica de la función.

# nbi:hide_in
IFrame(src='https://phet.colorado.edu/sims/html/trig-tour/latest/trig-tour_en.html',width="800", height="600",scrolling="yes")

Copyright

The notebook is provided as Open Educational Resource. Feel free to use the notebook for your own educational purposes. The text is licensed under Creative Commons Attribution-NoComercial 4.0 Internacional, the code of the IPython examples under the MIT license. Please attribute the work as follows: Aplicaciones de electrónica Analógica by Nicolás Ferragamo.

Licencia Creative Commons